TypeScript Node.js: Servera puses tipu drošības ieviešana

Pastāvīgi mainīgajā tīmekļa izstrādes ainavā stabila un uzturējama servera puses lietojumprogrammu izveide ir vissvarīgākā. Lai gan JavaScript ilgu laiku ir bijusi tīmekļa valoda, tās dinamiskā daba dažkārt var izraisīt izpildlaika kļūdas un grūtības mērogot lielākus projektus. TypeScript, JavaScript virskopa, kas pievieno statisko tipēšanu, piedāvā spēcīgu risinājumu šīm problēmām. TypeScript apvienošana ar Node.js nodrošina pārliecinošu vidi tipdrošu, mērogojamu un uzturējamu aizmugursistēmu izveidei.

Kāpēc izmantot TypeScript Node.js servera puses izstrādei?

TypeScript sniedz daudz priekšrocību Node.js izstrādei, risinot daudzus ierobežojumus, kas raksturīgi JavaScript dinamiskajai tipēšanai.

• Uzlabota tipu drošība: TypeScript nodrošina stingru tipu pārbaudi kompilēšanas laikā, notverot potenciālās kļūdas, pirms tās nonāk ražošanā. Tas samazina izpildlaika izņēmumu risku un uzlabo jūsu lietojumprogrammas kopējo stabilitāti. Iedomājieties scenāriju, kurā jūsu API gaida lietotāja ID kā skaitli, bet saņem virkni. TypeScript atzīmētu šo kļūdu izstrādes laikā, novēršot potenciālu avāriju ražošanā.
• Uzlabota koda uzturējamība: Tipu anotācijas padara kodu vieglāk saprotamu un refaktorējamu. Strādājot komandā, skaidras tipu definīcijas palīdz izstrādātājiem ātri saprast dažādu koda bāzes daļu mērķi un sagaidāmo uzvedību. Tas ir īpaši svarīgi ilgtermiņa projektiem ar mainīgām prasībām.
• Uzlabots IDE atbalsts: TypeScript statiskā tipēšana ļauj IDE (Integrētās izstrādes vides) nodrošināt izcilu automātisko pabeigšanu, koda navigāciju un refaktorēšanas rīkus. Tas ievērojami uzlabo izstrādātāju produktivitāti un samazina kļūdu iespējamību. Piemēram, VS Code TypeScript integrācija piedāvā inteliģentus ieteikumus un kļūdu izcelšanu, padarot izstrādi ātrāku un efektīvāku.
• Agrīna kļūdu atklāšana: Identificējot ar tipiem saistītas kļūdas kompilēšanas laikā, TypeScript ļauj jums novērst problēmas agri izstrādes ciklā, ietaupot laiku un samazinot atkļūdošanas pūles. Šī proaktīvā pieeja novērš kļūdu izplatīšanos lietojumprogrammā un ietekmi uz lietotājiem.
• Pakāpeniska ieviešana: TypeScript ir JavaScript virskopa, kas nozīmē, ka esošo JavaScript kodu var pakāpeniski migrēt uz TypeScript. Tas ļauj ieviest tipu drošību pakāpeniski, neprasot pilnīgu koda bāzes pārrakstīšanu.

TypeScript Node.js projekta iestatīšana

Lai sāktu darbu ar TypeScript un Node.js, jums būs jāinstalē Node.js un npm (Node Package Manager). Kad tie ir instalēti, varat veikt šādas darbības, lai iestatītu jaunu projektu:

1. Izveidojiet projekta direktoriju: Izveidojiet jaunu direktoriju savam projektam un terminālī pārejiet uz to.
2. Inicializējiet Node.js projektu: Palaidiet npm init -y, lai izveidotu package.json failu.
3. Instalējiet TypeScript: Palaidiet npm install --save-dev typescript @types/node, lai instalētu TypeScript un Node.js tipu definīcijas. @types/node pakotne nodrošina tipu definīcijas Node.js iebūvētajiem moduļiem, ļaujot TypeScript saprast un apstiprināt jūsu Node.js kodu.
4. Izveidojiet TypeScript konfigurācijas failu: Palaidiet npx tsc --init, lai izveidotu tsconfig.json failu. Šis fails konfigurē TypeScript kompilatoru un norāda kompilēšanas opcijas.
5. Konfigurējiet tsconfig.json: Atveriet tsconfig.json failu un konfigurējiet to atbilstoši sava projekta vajadzībām. Dažas bieži lietotas opcijas ietver:
• target: Norāda ECMAScript mērķa versiju (piem., "es2020", "esnext").
• module: Norāda izmantojamo moduļu sistēmu (piem., "commonjs", "esnext").
• outDir: Norāda izvades direktoriju kompilētajiem JavaScript failiem.
• rootDir: Norāda saknes direktoriju TypeScript avota failiem.
• sourceMap: Iespējo avota karšu ģenerēšanu vieglākai atkļūdošanai.
• strict: Iespējo stingru tipu pārbaudi.
• esModuleInterop: Iespējo savietojamību starp CommonJS un ES moduļiem.

tsconfig.json faila paraugs varētu izskatīties šādi:

{
  "compilerOptions": {
    "target": "es2020",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "sourceMap": true,
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": [
    "src/**/*"
  ]
}

Šī konfigurācija norāda TypeScript kompilatoram kompilēt visus .ts failus src direktorijā, izvadīt kompilētos JavaScript failus dist direktorijā un ģenerēt avota kartes atkļūdošanai.

Pamata tipu anotācijas un saskarnes

TypeScript ievieš tipu anotācijas, kas ļauj jums skaidri norādīt mainīgo, funkciju parametru un atgriežamo vērtību tipus. Tas ļauj TypeScript kompilatoram veikt tipu pārbaudi un agri notvert kļūdas.

Pamattipi

TypeScript atbalsta šādus pamattipus:

• string: Pārstāv teksta vērtības.
• number: Pārstāv skaitliskas vērtības.
• boolean: Pārstāv Būla vērtības (true vai false).
• null: Pārstāv apzinātu vērtības neesamību.
• undefined: Pārstāv mainīgo, kuram nav piešķirta vērtība.
• symbol: Pārstāv unikālu un nemaināmu vērtību.
• bigint: Pārstāv patvaļīgas precizitātes veselus skaitļus.
• any: Pārstāv jebkura tipa vērtību (lietot taupīgi).
• unknown: Pārstāv vērtību, kuras tips nav zināms (drošāks par any).
• void: Pārstāv atgriežamās vērtības neesamību no funkcijas.
• never: Pārstāv vērtību, kas nekad nerodas (piem., funkcija, kas vienmēr met kļūdu).
• array: Pārstāv sakārtotu viena tipa vērtību kolekciju (piem., string[], number[]).
• tuple: Pārstāv sakārtotu vērtību kolekciju ar konkrētiem tipiem (piem., [string, number]).
• enum: Pārstāv nosauktu konstantu kopu.
• object: Pārstāv neprimitīvu tipu.

Šeit ir daži tipu anotāciju piemēri:

let name: string = "John Doe";
let age: number = 30;
let isStudent: boolean = false;

function greet(name: string): string {
  return `Hello, ${name}!`;
}

let numbers: number[] = [1, 2, 3, 4, 5];

let person: { name: string; age: number } = {
  name: "Jane Doe",
  age: 25,
};

Saskarnes (Interfaces)

Saskarnes definē objekta struktūru. Tās norāda īpašības un metodes, kurām objektam ir jābūt. Saskarnes ir spēcīgs veids, kā nodrošināt tipu drošību un uzlabot koda uzturējamību.

Šeit ir saskarnes piemērs:

interface User {
  id: number;
  name: string;
  email: string;
  isActive: boolean;
}

function getUser(id: number): User {
  // ... ielādēt lietotāja datus no datu bāzes
  return {
    id: 1,
    name: "John Doe",
    email: "john.doe@example.com",
    isActive: true,
  };
}

let user: User = getUser(1);

console.log(user.name); // John Doe

Šajā piemērā User saskarne definē lietotāja objekta struktūru. Funkcija getUser atgriež objektu, kas atbilst User saskarnei. Ja funkcija atgriež objektu, kas neatbilst saskarnei, TypeScript kompilators izmetīs kļūdu.

Tipu aizstājvārdi (Type Aliases)

Tipu aizstājvārdi izveido jaunu nosaukumu tipam. Tie neizveido jaunu tipu - tie tikai piešķir esošam tipam aprakstošāku vai ērtāku nosaukumu.

type StringOrNumber = string | number;

let value: StringOrNumber = "hello";
value = 123;

//Tipa aizstājvārds sarežģītam objektam
type Point = {
 x: number;
 y: number;
};

const myPoint: Point = { x: 10, y: 20 };

Vienkārša API izveide ar TypeScript un Node.js

Izveidosim vienkāršu REST API, izmantojot TypeScript, Node.js un Express.js.

1. Instalējiet Express.js un tā tipu definīcijas: Palaidiet npm install express @types/express
2. Izveidojiet failu ar nosaukumu src/index.ts ar šādu kodu:

import express, { Request, Response } from 'express';

const app = express();
const port = process.env.PORT || 3000;

interface Product {
  id: number;
  name: string;
  price: number;
}

const products: Product[] = [
  { id: 1, name: 'Laptop', price: 1200 },
  { id: 2, name: 'Keyboard', price: 75 },
  { id: 3, name: 'Mouse', price: 25 },
];

app.get('/products', (req: Request, res: Response) => {
  res.json(products);
});

app.get('/products/:id', (req: Request, res: Response) => {
  const productId = parseInt(req.params.id);
  const product = products.find(p => p.id === productId);

  if (product) {
    res.json(product);
  } else {
    res.status(404).json({ message: 'Product not found' });
  }
});

app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

Šis kods izveido vienkāršu Express.js API ar diviem galapunktiem:

• /products: Atgriež produktu sarakstu.
• /products/:id: Atgriež konkrētu produktu pēc ID.

Saskarne Product definē produkta objekta struktūru. Masīvs products satur produktu objektu sarakstu, kas atbilst Product saskarnei.

Lai palaistu API, jums būs jākompilē TypeScript kods un jāstartē Node.js serveris:

1. Kompilējiet TypeScript kodu: Palaidiet npm run tsc (iespējams, jums būs jādefinē šis skripts package.json kā "tsc": "tsc").
2. Startējiet Node.js serveri: Palaidiet node dist/index.js.

Pēc tam varat piekļūt API galapunktiem savā pārlūkprogrammā vai ar rīku, piemēram, curl:

curl http://localhost:3000/products
curl http://localhost:3000/products/1

Progresīvas TypeScript tehnikas servera puses izstrādei

TypeScript piedāvā vairākas progresīvas funkcijas, kas var vēl vairāk uzlabot tipu drošību un koda kvalitāti servera puses izstrādē.

Ģenēriki (Generics)

Ģenēriki ļauj rakstīt kodu, kas var strādāt ar dažādiem tipiem, nezaudējot tipu drošību. Tie nodrošina veidu, kā parametrizēt tipus, padarot jūsu kodu atkārtoti lietojamu un elastīgāku.

Šeit ir ģenēriskas funkcijas piemērs:

function identity<T>(arg: T): T {
  return arg;
}

let myString: string = identity<string>("hello");
let myNumber: number = identity<number>(123);

Šajā piemērā funkcija identity pieņem argumentu ar tipu T un atgriež vērtību ar to pašu tipu. Sintakse <T> norāda, ka T ir tipa parametrs. Izsaucot funkciju, jūs varat skaidri norādīt T tipu (piem., identity<string>) vai ļaut TypeScript to secināt no argumenta (piem., identity("hello")).

Diskriminētās apvienības (Discriminated Unions)

Diskriminētās apvienības, pazīstamas arī kā marķētās apvienības, ir spēcīgs veids, kā attēlot vērtības, kas var būt viens no vairākiem dažādiem tipiem. Tās bieži izmanto, lai modelētu stāvokļu mašīnas vai attēlotu dažāda veida kļūdas.

Šeit ir diskriminētās apvienības piemērs:

type Success = {
  status: 'success';
  data: any;
};

type Error = {
  status: 'error';
  message: string;
};

type Result = Success | Error;

function handleResult(result: Result) {
  if (result.status === 'success') {
    console.log('Success:', result.data);
  } else {
    console.error('Error:', result.message);
  }
}

const successResult: Success = { status: 'success', data: { name: 'John Doe' } };
const errorResult: Error = { status: 'error', message: 'Something went wrong' };

handleResult(successResult);
handleResult(errorResult);

Šajā piemērā tips Result ir diskriminētā apvienība no Success un Error tipiem. Īpašība status ir diskriminators, kas norāda, kuram tipam vērtība pieder. Funkcija handleResult izmanto diskriminatoru, lai noteiktu, kā apstrādāt vērtību.

Palīgtipi (Utility Types)

TypeScript nodrošina vairākus iebūvētus palīgtipus, kas var palīdzēt manipulēt ar tipiem un izveidot kodolīgāku un izteiksmīgāku kodu. Daži bieži lietoti palīgtipi ietver:

• Partial<T>: Padara visas T īpašības par neobligātām.
• Required<T>: Padara visas T īpašības par obligātām.
• Readonly<T>: Padara visas T īpašības par tikai lasāmām.
• Pick<T, K>: Izveido jaunu tipu tikai ar tām T īpašībām, kuru atslēgas ir K.
• Omit<T, K>: Izveido jaunu tipu ar visām T īpašībām, izņemot tās, kuru atslēgas ir K.
• Record<K, T>: Izveido jaunu tipu ar atslēgām no tipa K un vērtībām no tipa T.
• Exclude<T, U>: Izslēdz no T visus tipus, kas ir piešķirami U.
• Extract<T, U>: Izvelk no T visus tipus, kas ir piešķirami U.
• NonNullable<T>: Izslēdz null un undefined no T.
• Parameters<T>: Iegūst funkcijas tipa T parametrus kortežā (tuple).
• ReturnType<T>: Iegūst funkcijas tipa T atgriežamo tipu.
• InstanceType<T>: Iegūst konstruktora funkcijas tipa T instances tipu.

Šeit ir daži piemēri, kā izmantot palīgtipus:

interface User {
  id: number;
  name: string;
  email: string;
}

// Padarīt visas User īpašības par neobligātām
type PartialUser = Partial<User>;

// Izveidot tipu tikai ar User name un email īpašībām
type UserInfo = Pick<User, 'name' | 'email'>;

// Izveidot tipu ar visām User īpašībām, izņemot id
type UserWithoutId = Omit<User, 'id'>;

TypeScript Node.js lietojumprogrammu testēšana

Testēšana ir būtiska daļa no stabilu un uzticamu servera puses lietojumprogrammu izveides. Izmantojot TypeScript, jūs varat izmantot tipu sistēmu, lai rakstītu efektīvākus un uzturējamākus testus.

Populāri testēšanas ietvari Node.js ir Jest un Mocha. Šie ietvari nodrošina dažādas funkcijas vienību testu, integrācijas testu un end-to-end testu rakstīšanai.

Šeit ir vienības testa piemērs, izmantojot Jest:

// src/utils.ts
export function add(a: number, b: number): number {
  return a + b;
}

// test/utils.test.ts
import { add } from '../src/utils';

describe('add', () => {
  it('should return the sum of two numbers', () => {
    expect(add(1, 2)).toBe(3);
  });

  it('should handle negative numbers', () => {
    expect(add(-1, 2)).toBe(1);
  });
});

Šajā piemērā funkcija add tiek testēta, izmantojot Jest. Bloks describe grupē saistītos testus. Bloki it definē atsevišķus testa gadījumus. Funkcija expect tiek izmantota, lai veiktu apgalvojumus par koda uzvedību.

Rakstot testus TypeScript kodam, ir svarīgi nodrošināt, ka jūsu testi aptver visus iespējamos tipu scenārijus. Tas ietver testēšanu ar dažādu veidu ievaddatiem, testēšanu ar null un undefined vērtībām un testēšanu ar nederīgiem datiem.

Labākās prakses TypeScript Node.js izstrādē

Lai nodrošinātu, ka jūsu TypeScript Node.js projekti ir labi strukturēti, uzturējami un mērogojami, ir svarīgi ievērot dažas labākās prakses:

• Izmantojiet stingro režīmu: Iespējojiet stingro režīmu savā tsconfig.json failā, lai nodrošinātu stingrāku tipu pārbaudi un agri atklātu potenciālās kļūdas.
• Definējiet skaidras saskarnes un tipus: Izmantojiet saskarnes un tipus, lai definētu savu datu struktūru un nodrošinātu tipu drošību visā lietojumprogrammā.
• Izmantojiet ģenērikus: Izmantojiet ģenērikus, lai rakstītu atkārtoti lietojamu kodu, kas var strādāt ar dažādiem tipiem, nezaudējot tipu drošību.
• Izmantojiet diskriminētās apvienības: Izmantojiet diskriminētās apvienības, lai attēlotu vērtības, kas var būt viens no vairākiem dažādiem tipiem.
• Rakstiet visaptverošus testus: Rakstiet vienību testus, integrācijas testus un end-to-end testus, lai nodrošinātu, ka jūsu kods darbojas pareizi un ka jūsu lietojumprogramma ir stabila.
• Ievērojiet konsekventu kodēšanas stilu: Izmantojiet koda formatētāju, piemēram, Prettier, un linteri, piemēram, ESLint, lai nodrošinātu konsekventu kodēšanas stilu un atklātu potenciālās kļūdas. Tas ir īpaši svarīgi, strādājot komandā, lai uzturētu konsekventu koda bāzi. ESLint un Prettier ir daudz konfigurācijas iespēju, kuras var koplietot komandā.
• Izmantojiet atkarību injekciju: Atkarību injekcija ir dizaina modelis, kas ļauj atsaistīt kodu un padarīt to vieglāk testējamu. Rīki, piemēram, InversifyJS, var palīdzēt jums ieviest atkarību injekciju jūsu TypeScript Node.js projektos.
• Ieviesiet pareizu kļūdu apstrādi: Ieviesiet stabilu kļūdu apstrādi, lai eleganti notvertu un apstrādātu izņēmumus. Izmantojiet try-catch blokus un kļūdu reģistrēšanu, lai novērstu lietojumprogrammas avāriju un nodrošinātu noderīgu atkļūdošanas informāciju.
• Izmantojiet moduļu saiņotāju: Izmantojiet moduļu saiņotāju, piemēram, Webpack vai Parcel, lai saiņotu savu kodu un optimizētu to ražošanai. Lai gan bieži saistīti ar frontend izstrādi, moduļu saiņotāji var būt noderīgi arī Node.js projektiem, īpaši strādājot ar ES moduļiem.
• Apsveriet ietvara izmantošanu: Izpētiet ietvarus, piemēram, NestJS vai AdonisJS, kas nodrošina struktūru un konvencijas mērogojamu un uzturējamu Node.js lietojumprogrammu izveidei ar TypeScript. Šie ietvari bieži ietver tādas funkcijas kā atkarību injekcija, maršrutēšana un starpprogrammatūras atbalsts.

Ieviešanas apsvērumi

TypeScript Node.js lietojumprogrammas ieviešana ir līdzīga standarta Node.js lietojumprogrammas ieviešanai. Tomēr ir daži papildu apsvērumi:

• Kompilēšana: Jums būs jākompilē savs TypeScript kods uz JavaScript, pirms to ieviest. To var izdarīt kā daļu no jūsu būvēšanas procesa.
• Avota kartes (Source Maps): Apsveriet avota karšu iekļaušanu savā ieviešanas paketē, lai atvieglotu atkļūdošanu ražošanā.
• Vides mainīgie: Izmantojiet vides mainīgos, lai konfigurētu savu lietojumprogrammu dažādām vidēm (piem., izstrāde, sagatavošana, ražošana). Tā ir standarta prakse, bet kļūst vēl svarīgāka, strādājot ar kompilētu kodu.

Populāras ieviešanas platformas Node.js ietver:

• AWS (Amazon Web Services): Piedāvā dažādus pakalpojumus Node.js lietojumprogrammu ieviešanai, tostarp EC2, Elastic Beanstalk un Lambda.
• Google Cloud Platform (GCP): Nodrošina līdzīgus pakalpojumus kā AWS, tostarp Compute Engine, App Engine un Cloud Functions.
• Microsoft Azure: Piedāvā tādus pakalpojumus kā Virtual Machines, App Service un Azure Functions Node.js lietojumprogrammu ieviešanai.
• Heroku: Platforma kā pakalpojums (PaaS), kas vienkāršo Node.js lietojumprogrammu ieviešanu un pārvaldību.
• DigitalOcean: Nodrošina virtuālos privātos serverus (VPS), kurus varat izmantot Node.js lietojumprogrammu ieviešanai.
• Docker: Konteinerizācijas tehnoloģija, kas ļauj jums iepakot savu lietojumprogrammu un tās atkarības vienā konteinerī. Tas atvieglo lietojumprogrammas ieviešanu jebkurā vidē, kas atbalsta Docker.

Noslēgums

TypeScript piedāvā ievērojamu uzlabojumu salīdzinājumā ar tradicionālo JavaScript, veidojot stabilas un mērogojamas servera puses lietojumprogrammas ar Node.js. Izmantojot tipu drošību, uzlabotu IDE atbalstu un progresīvas valodas funkcijas, jūs varat izveidot uzturējamākas, uzticamākas un efektīvākas aizmugursistēmas. Lai gan TypeScript apguvei ir nepieciešams laiks, ilgtermiņa ieguvumi koda kvalitātes un izstrādātāju produktivitātes ziņā padara to par vērtīgu ieguldījumu. Tā kā pieprasījums pēc labi strukturētām un uzturējamām lietojumprogrammām turpina pieaugt, TypeScript kļūs par arvien svarīgāku rīku servera puses izstrādātājiem visā pasaulē.